//// 注意： 使用Scanner类，需要在最前面加上 导入的这个类，才能够正常使用
//import java.util.Scanner;
//
//public class Operator{
//    public static void main(String[] args){
//        System.out.println("Operator");
//    }
//
//    /**
//     * 算数操作符
//     */
//    void Arithmetic() {
//        /**
//         * 基本算数操作符
//         *      加减乘除： + - * /
//         */
//        int i1 = 10;
//        int j1 = 5;
//        int a1 = i1 + j1;
//        int b1 = i1 - j1;
//        int c1 = i1 * j1;
//        int d1 = i1 / j1;
//
//        /**
//         * 任意运算单元的长度 超过 int
//         *      如果有任何运算单元的长度超过int,那么运算结果就按照最长的长度计算
//         */
//        int a2 = 5;
//        long b2 = 6;
//        int c2 = (int) (a2 + b2); // a+b的运算结果是long型，所以要进行强制转换
//        long d2 = a2 + b2;
//
//        /**
//         * 任意运算单元的长度 小于 int
//         *      如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算
//         */
//        byte a3 = 1;
//        byte b3 = 2;
//        byte c3 = (byte) (a3 + b3); //虽然a b都是byte类型，但是运算结果是int类型，需要进行强制转换
//        int d3 = a3 + b3;
//
//        /**
//         *  %取模
//         *      % 取余数，又叫取模
//         */
//        int i4 = 5;
//        int j4 = 2;
//        System.out.println(i4 % j4); //输出为1
//
//        /**
//         * 自增++  自减--
//         */
//        int i5 = 5;
//        i5++;
//        System.out.println(i5); //输出为6
//
//        /**
//         * 自增自减操作符 置前以及置后的区别
//         *      i++; 先取值，再运算
//         *      ++i; 先运算，再取值
//         */
//        int i6 = 5;
//        System.out.println(i6++); //输出5
//        System.out.println(i6);   //输出6
//
//        int j6 = 5;
//        System.out.println(++j6); //输出6
//        System.out.println(j6);   //输出6
//    }
//
//
//    /**
//     * 关系操作符
//     */
//    void Relationship() {
//        /**
//         * 关系操作符
//         *      >  大于
//         *      >= 大于或等于
//         *      <  小于
//         *      <= 小于或等于
//         *      == 是否相等
//         *      != 是否不等
//         */
//        int a = 5;
//        int b = 6;
//        int c = 5;
//
//        System.out.println(a > b);  //返回 false
//        System.out.println(a >= c); //返回 true
//
//        System.out.println(a == b); //返回false
//        System.out.println(a != b); //返回true
//    }
//
//
//    /**
//     * 逻辑操作符
//     */
//    void Logic() {
//        /**
//         *  长路与 &  、 短路与 &&
//         *      无论长路与还是短路与
//         *          两边的运算单元都是布尔值
//         *          都为真时，才为真
//         *          任意为假，就为假
//         *      区别
//         *          长路与 两侧，都会被运算
//         *          短路与 只要第一个是false，第二个就不进行运算了
//         */
//        //长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
//        int i1 = 2;
//        System.out.println( i1 == 1 & i1++ == 2  ); //无论如何i++都会被执行，所以i的值变成了3
//        System.out.println(i1);
//
//        //短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
//        int j1 = 2;
//        System.out.println( j1 == 1 && j1++ == 2  );  //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
//        System.out.println(j1);
//
//        /**
//         *  长路或 |  、 短路或 ||
//         *      无论长路或还是短路或
//         *          两边的运算单元都是布尔值
//         *          都为假时，才为假
//         *          任意为真，就为真
//         *      区别
//         *          长路或 两侧都会被运算
//         *          短路或 只要第一个是true的，第二个就不进行运算了
//         */
//        //长路或  无论第一个表达式的值是true或者false,第二个的值，都会被运算
//        int i2 = 2;
//        System.out.println( i2 == 1 | i2++ == 2  ); //无论如何i++都会被执行，所以i的值变成了3
//        System.out.println(i2);
//
//        //短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
//        int j2 = 2;
//        System.out.println( j2 == 2 || j2++ == 2  );  //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
//        System.out.println(j2);
//
//        /**
//         * 取反 !
//         */
//        boolean b3 = true;
//        System.out.println(b3);  //输出 true
//        System.out.println(!b3); //输出 false
//
//        /**
//         * 异或 ^
//         *      不同，返回真
//         *      相同，返回假
//         */
//        boolean a4 = true;
//        boolean b4 = false;
//        System.out.println(a4 ^ b4);  //不同返回真
//        System.out.println(a4 ^ !b4); //相同返回假
//    }
//
//
//    /**
//     * 位操作符
//     */
//    void Bit() {
//        /**
//         * 一个整数的二进制表达
//         *      通过 Integer.toBinaryString() 方法，将一个十进制整数转换为一个二进制字符串
//         */
//        int i1 = 5;
//        String b1 = (Integer.toBinaryString(i1)); // 5的二进制的表达101
//        System.out.println(i1 + " 的二进制表达是: " + b1);
//
//        /**
//         * 位或 |
//         */
//        int i2  =5;
//        int j2 = 6;
//        System.out.println(Integer.toBinaryString(i2)); //5的二进制是101
//        System.out.println(Integer.toBinaryString(j2)); //6的二进制是110
//        System.out.println(i2 | j2); //所以 5|6 对每一位进行或运算，得到 111->7
//
//        /**
//         * 位与 &
//         */
//        int i3  =5;
//        int j3 = 6;
//        System.out.println(Integer.toBinaryString(i3)); //5的二进制是101
//        System.out.println(Integer.toBinaryString(j3)); //6的二进制是110
//        System.out.println(i3 & j3); //所以 5&6 对每一位进行与运算，得到 100->4
//
//        /**
//         * 异或 ^
//         */
//        int i4  =5;
//        int j4 = 6;
//        System.out.println(Integer.toBinaryString(i4)); //5的二进制是 101
//        System.out.println(Integer.toBinaryString(j4)); //6的二进制是110
//        System.out.println(i4 ^ j4); //所以 5^6 对每一位进行或运算，得到 011->3
//        // 一些特别情况：
//        //      任何数和自己进行异或 都等于 0
//        //      任何数和0 进行异或 都等于自己
//        System.out.println(i4 ^ 0);
//        System.out.println(i4 ^ i4);
//
//        /**
//         * 取非 ~
//         */
//        byte i5 = 5;
//        System.out.println(Integer.toBinaryString(i5)); //5的二进制是00000101,所以取非即为11111010,即为-6
//        System.out.println(~i5);
//
//        /**
//         * 左移 << ：根据一个整数的二进制表达，将其每一位都向左移动，最右边一位补0
//         * 右移 >> ：根据一个整数的二进制表达，将其每一位都向右移动
//         */
//        byte i6 = 6;
//        //6的二进制是110
//        System.out.println(Integer.toBinaryString(i6));
//        //6向左移1位后，变成1100，对应的10进制是12
//        System.out.println(i6 << 1);
//        //6向右移1位后，变成11，对应的10进制是3
//        System.out.println(i6 >> 1);
//
//        /**
//         * 带符号右移 >>
//         *      对于正数， 带符号右移 >> 会把所有的位右移，并在最前面补0
//         *      对于负数， 带符号右移 >> 会把所有的位右移，并在最前面补1
//         * 无符号右移 >>>
//         *      如果是一个负数，那么对应的二进制的第一位是1
//         *      无符号右移会把第一位的1也向右移动，导致移动后，第一位变成0， 这样就会使得负数在无符号右移后，得到一个正数
//         *
//         * 简单的说：
//         *      带符号右移 >> 移动后正的还是正的，负的还是负的,符号不变
//         *      无符号右移 >>> 移动后，变正的了
//         */
//        int i7 = -10;
//
//        //-10的二进制是11111111111111111111111111110110
//        //第一位是1，即符号位，代表这是一个负数
//        System.out.println(Integer.toBinaryString(i7));
//
//        //对于正数， 带符号右移 >> 会把所有的位右移，并在最前面补0
//        //对于负数， 带符号右移 >> 会把所有的位右移，并在最前面补1
//
//        //-10带符号右移1位，移动后前面补齐1
//        //得到11111111111111111111111111111011
//        //因为第一位是1，所以依然是一个负数，对应的十进制是-5
//        int j = i7 >> 1;
//        System.out.println(Integer.toBinaryString(j));
//        System.out.println(j);
//
//        //-10无符号向右移1位，符号位也会向右移，第一位就变成了0
//        //得到01111111111111111111111111111011，对应的十进制是2147483643
//        int k7 = i7 >>> 1;
//        System.out.println(Integer.toBinaryString(k7));
//
//        System.out.println(k7);
//    }
//
//
//    /**
//     * 赋值操作符
//     */
//    void Assignment() {
//        /**
//         * 赋值操作 的操作顺序是从右到左
//         */
//        int i = 5+5; // 首先进行5+5的运算，得到结果10，然后把10这个值，赋给i
//
//        /**
//         * 对本身进行运算，并赋值
//         *      +=即自加;  eg：i+=2 等同于 i=i+2;
//         *      其他的 -= , *= , /= , %= , &= , |= , ^= , >>= , >>>= 都是类似，不做赘述
//         */
//        int i1 = 3;
//        i1 += 2;
//        System.out.println(i1);
//
//        int j1 = 3;
//        j1 = j1 + 2;
//        System.out.println(j1);
//    }
//
//
//    /**
//     * 三元操作符
//     */
//    void Ternary() {
//        /**
//         * 表达式 ? 值1 : 值2
//         *      如果表达式为真，返回 值1
//         *      如果表达式为假，返回 值2
//         */
//        int i = 5;
//        int j = 6;
//
//        int k = i < j ? 99 : 88;
//        // 相当于
//        if (i < j) {
//            k = 99;
//        } else {
//            k = 88;
//        }
//        System.out.println(k);
//    }
//
//
//    /**
//     * Scanner ： 从控制台输入数据，需要用到Scanner类
//     */
//    void Scanner() {
//        Scanner s = new Scanner(System.in);
//
//        /**
//         * 使用 Scanner 读取整数
//         */
//        int a1 = s.nextInt();
//        System.out.println("第一个整数：" + a1);
//        int b1 = s.nextInt();
//        System.out.println("第二个整数：" + b1);
//
//        /**
//         * 使用 Scanner 读浮点数
//         */
//        float a2 = s.nextFloat();
//        System.out.println("读取的浮点数的值是：" + a2);
//
//        /**
//         * 使用 Scanner 读取字符串
//         */
//        String a3 = s.nextLine();
//        System.out.println("读取的字符串是：" + a3);
//
//        /**
//         * 读取了整数后，接着读取字符串
//         *      需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n", 因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".
//         *      所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串
//         */
//        int i4 = s.nextInt();
//        System.out.println("读取的整数是" + i4);
//        String rn = s.nextLine();
//        String a4 = s.nextLine();
//        System.out.println("读取的字符串是：" + a4);
//    }
//
//}